package com.web.model;

import com.jfinal.plugin.activerecord.Db;
import com.jfinal.plugin.activerecord.Model;
import com.jfinal.plugin.activerecord.Page;
import com.jfinal.plugin.activerecord.Record;
import com.web.util.HtmlStringHandler;
import com.web.util.QuotationTransfer;
import org.apache.log4j.Logger;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * Created by reeves on 2015/10/5.
 */
/*
page_edit表
+----------------+--------------+------+-----+---------+----------------+
| Field          | Type         | Null | Key | Default | Extra          |
+----------------+--------------+------+-----+---------+----------------+
| id             | mediumint(9) | NO   | PRI |         | auto_increment |
| uploadDate     | date         | YES  |     |         |                |
| pageDate       | date         | YES  |     |         |                |
| pageContent    | longtext     | YES  |     |         |                |
| titleImage     | varchar(15)  | YES  |     |         |                |
| firstTitle     | varchar(64)  | YES  |     |         |                |
| typeId         | mediumint(4) | NO   |     |         |                |
| editorId       | varchar(20)  | YES  |     |         |                |
| pageType       | tinyint(4)   | NO   |     |         |                |
| pageFrom       | varchar(40)  | YES  |     |         |                |
| sourceAddress  | varchar(500) | YES  |     |         |                |
| recomPos       | tinyint(2)   | NO   |     |    -1   |                |
| isReady        | tinyint(2)   | NO   |     |    0    |                |
+----------------+--------------+------+-----+---------+----------------+
*/
public class PageEdit extends Model<PageEdit>{
    public static final PageEdit pageEditDao = new PageEdit();
    private static final Logger LOGGER = Logger.getLogger(PageEdit.class);


    /**
     * 对编辑人员上传的内容做出一定处理之后，返回存储用的PageEdit对象
     *
     * @param date
     * @param editThirdId
     * @param title
     * @param source
     * @param imageId
     * @param content
     * @param sourceAddress
     * @return
     */
    public PageEdit processBeforeStore(String editorId,Date date, int editThirdId, String title, String source, String imageId, int imageType, String content, String sourceAddress) throws IOException {

        PageEdit pageEdit = new PageEdit();
        /**
         * 对原来的文章内容做一定处理之后再存储
         */
        // 对正文做处理
        content = HtmlStringHandler.formatHtml(content);

        //将标题中的英文双引号变成中文双引号
        title = QuotationTransfer.processQuotationMarks(title);

        /**
         * 根据编辑人员输入的ID找到真实的三级分类ID
         */
        int thirdID = TypeInfo.typeInfoDao.getThirdIdByEditor(editThirdId);
        if (thirdID == 0) {
            LOGGER.error("根据编辑人员的ID值无法找到三级分类ID,编辑人员编辑ID为: " + editThirdId);
            return null;
        }

        /**
         * 根据标题筛选，避免文章重复
         */
        int pageid = pageEditDao.getPageByTitle(title);
        if (pageid == 0){
            LOGGER.error("文章出现重复了");
            return null;
        }

        /**
         * 根据编辑人员选择的日期来创建对应的日期对象，并格式化为 yyyy-MM-dd 形式的字符串
         */
        /*Date dt = new Date();
        Calendar calendar = new GregorianCalendar();
        switch (dateFlag) {
            case 1:
                calendar.setTime(dt);
                calendar.add(calendar.DATE,1);//把日期往后增加 1 天.整数往后推,负数往前移动
                dt=calendar.getTime(); //这个时间就是日期往后推 1 天的结果
                break;
            case 2:
                calendar.setTime(dt);
                calendar.add(calendar.DATE,2);
                dt=calendar.getTime();
                break;
            case 3:
                calendar.setTime(dt);
                calendar.add(calendar.DATE,3);
                dt=calendar.getTime();
                break;
        }*/

        /*SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
        String dateString = formatter.format(date);*/

        /**
         * 创建拥有处理好的全部数据的对象并返回
         */
        pageEdit.set("pageDate", date).set("uploadDate",new Date()).set("pageContent", content).set("titleImage", imageId).set("firstTitle", title).set("secondTitle",title).set("typeId", thirdID).set("editorId", editorId).set("pageType", 0).set("pageFrom", source).set("sourceAddress", sourceAddress).set("infoImgType",imageType);

        return pageEdit;
    }

    /**
     * 根据标题删选出文章，筛选到就返回1，否则为0
     */
    public int getPageByTitle(String title){
        List<PageEdit> pageEdits = pageEditDao.find("SELECT id FROM page_edit WHERE firstTitle = ?",title);
        if(pageEdits.size()>=1){
//            System.out.println("找到重复的文章");
            return 0;
        }
        else{
            return 1;
        }
    }

    /**
     * 更新第二个标题，为了推荐页面显示用
     */
    public void updateSecTitle(int pageId, String newTitle){
        pageEditDao.findById(pageId).set("secondTitle",newTitle).update();
    }

    /**
     *更新正文
     */
    public void updatePage(int pageId, String content) throws IOException {
        content = HtmlStringHandler.formatHtml(content);
        pageEditDao.findById(pageId).set("pageContent", content).update();
    }

    /**
     * 更新图片到数据库
     * @param pageId
     * @param imageId
     */
    public void updatePic(int pageId, String imageId){
        pageEditDao.findById(pageId).set("titleImage", imageId).update();
    }
    /**
     * 存储编辑内容
     * (日期字符，文章内容，图片ID，标题，三级分类ID，阅读数，编辑ID，文章类型，文章来源，文章原网址)
     * 使用PageEdit对象作为存储参数，类似于Hibernate
     *
     * @param pageEdit
     */
    public void storePageInfo(PageEdit pageEdit) {
        try {
            new PageEdit().set("pageDate", pageEdit.get("pageDate")).set("uploadDate",pageEdit.get("uploadDate")).set("pageContent", pageEdit.get("pageContent")).set("titleImage", pageEdit.get("titleImage"))
                    .set("firstTitle", pageEdit.get("firstTitle")).set("secondTitle",pageEdit.get("firstTitle")).set("typeId", pageEdit.get("typeId")).set("editorId", pageEdit.get("editorId")).set("pageType", pageEdit.get("pageType"))
                    .set("pageFrom", pageEdit.get("pageFrom")).set("sourceAddress", pageEdit.get("sourceAddress")).set("infoImgType",pageEdit.get("infoImgType")).save();
        } catch (Exception exception) {
            LOGGER.error("存储编辑内容错误...", exception);
        }
    }

    /**
     * 获取三级界面今天编辑的将要推送的信息，按时间从早到晚排序，先出现明天推送的，再出现之后即将推送的，网页端显示时需要有明显区隔
     * 三级分类界面：1. 信息可以进行查看和审核；2. 如果某个三级分类信息在滑图中，则此显示风格不变，在一级分类界面显示风格有变；3. 时间从前往后；
     *
     * @param pageNumber
     * @param pageSize
     * @param thirdType
     */
    public Page<Record> getThirdPage(int pageNumber, int pageSize, int thirdType) {
        return Db.paginate(pageNumber, pageSize, "SELECT page_edit.id,pageDate,pageType,name,imageSrc,editorId,firstTitle,editTypeId,pageFrom,recomPos,sourceAddress,isReady",
                "FROM page_edit,page_titleimage,type_info,com_userinfo WHERE page_edit.titleImage=page_titleimage.imageId AND page_edit.editorId=com_userinfo.id AND page_edit.typeId=type_info.id AND typeId=? ORDER BY pageDate DESC,uploadDate DESC,isReady ASC", thirdType);
    }

    /**
     * 获取今日上传的特定三级分类信息总数
     * 信息总数：1. 信息都是今天上传的；
     *
     * @param pageSize
     * @param thirdType
     * @return
     */
    public int getPageNumberThird(int pageSize, int thirdType) {
        Long countLong = Db.queryLong("SELECT COUNT(*) FROM page_edit WHERE typeId=?", thirdType);
        int count = countLong.intValue();
        return count % pageSize == 0 ? (count / pageSize) : (count / pageSize + 1);
    }

    /**
     * 获取我的编辑页面数据信息
     * 我的编辑页面：1. 全部是今天编辑的新的信息；2. 可以查看审核状态；3. 相同分类在一起显示；4. 可以进行轻编辑和正文修改；
     *
     * @param editorId
     * @param pageNumber
     * @param pageSize
     * @return
     */
    public Page<Record> getEditorPage(String editorId, int pageNumber, int pageSize){
        return Db.paginate(pageNumber, pageSize, "SELECT page_edit.id,pageDate,thirdTypeName,editTypeId,imageSrc,firstTitle,pageFrom,recomPos,pageType,sourceAddress,isReady",
                "FROM page_edit,page_titleimage,type_info WHERE page_edit.titleImage=page_titleimage.imageId AND page_edit.typeId=type_info.id AND editorId=? ORDER BY pageDate DESC,uploadDate DESC,typeId ASC", editorId);
    }

    /**
     * 获取编辑我的编辑界面的信息条数
     * 我的编辑信息条数：1. 今天上传的信息条数；
     *
     * @param editorId
     * @param pageSize
     * @return
     */
    public int getEditorPageNumber(String editorId, int pageSize){
        Long countLong = Db.queryLong("SELECT COUNT(*) FROM page_edit WHERE editorId=?",editorId);
        int count = countLong.intValue();
        return count % pageSize == 0 ? (count / pageSize) : (count / pageSize + 1);
    }

    /**
     * 获取推荐集中营的信息列表
     * 推荐信息集中营（不同于推荐分类的信息）：1. 信息的推荐标志位等于0（设置好推荐信息的位置后，不在推荐集中营中出现），即编辑人员推荐此条信息；2. 推荐的信息必须是审核过的才能在推荐分类中出现；3. 推荐信息可以进行选位置，没有选位置的推荐信息没有任何意义，和普通信息一样；
     *
     * @param pageNumber
     * @param pageSize
     * @return
     */
    public Page<Record> getRecom(int pageNumber,int pageSize){
        return Db.paginate(pageNumber, pageSize, "SELECT page_edit.id,pageDate,editorId,imageId,imageSrc,name,imageSource,firstTitle,thirdTypeName,pageFrom,sourceAddress",
                "FROM page_edit,page_titleimage,type_info,com_userinfo WHERE page_edit.titleImage=page_titleimage.imageId AND page_edit.editorId=com_userinfo.id AND page_edit.typeId=type_info.id AND pageType=0 AND recomPos=0 AND isReady=1 ORDER BY pageDate DESC,typeId ASC");
    }

    /**
     * 获取推荐集中营里一级分类的信息列表
     */
    public Page<Record> getRecomFirst(int pageNumber,int pageSize,int firstType){
        return Db.paginate(pageNumber, pageSize,"SELECT page_edit.id,pageDate,editorId,imageId,imageSrc,name,imageSource,firstTitle,thirdTypeName,pageFrom,sourceAddress",
                "FROM page_edit,page_titleimage,type_info,com_userinfo WHERE page_edit.titleImage=page_titleimage.imageId AND page_edit.editorId=com_userinfo.id AND page_edit.typeId=type_info.id AND firstType=? AND pageType=0 AND recomPos=0 AND isReady=1 ORDER BY pageDate DESC,typeId ASC",firstType);
    }

    /**
     * 获取推荐集中营里二级分类的信息列表
     */
    public Page<Record> getRecomSecond(int pageNumber,int pageSize,int secondType){
        return Db.paginate(pageNumber, pageSize,"SELECT page_edit.id,pageDate,editorId,imageId,imageSrc,name,imageSource,firstTitle,thirdTypeName,pageFrom,sourceAddress",
                "FROM page_edit,page_titleimage,type_info,com_userinfo WHERE page_edit.titleImage=page_titleimage.imageId AND page_edit.editorId=com_userinfo.id AND page_edit.typeId=type_info.id AND secondType=? AND pageType=0 AND recomPos=0 AND isReady=1 ORDER BY pageDate DESC,typeId ASC",secondType);
    }

    /**
     * 获取推荐集中营里三级分类的信息列表
     */
    public Page<Record> getRecomThird(int pageNumber,int pageSize,int thirdType){
        return Db.paginate(pageNumber, pageSize,"SELECT page_edit.id,pageDate,editorId,imageId,imageSrc,name,imageSource,firstTitle,thirdTypeName,pageFrom,sourceAddress",
                "FROM page_edit,page_titleimage,type_info,com_userinfo WHERE page_edit.titleImage=page_titleimage.imageId AND page_edit.editorId=com_userinfo.id AND page_edit.typeId=type_info.id AND type_info.id=? AND pageType=0 AND recomPos=0 AND isReady=1 ORDER BY pageDate DESC,typeId ASC",thirdType);
    }

    /**
     * 获取推荐集中营信息的总条数
     * 推荐信息总数：1. 信息必须是审核过的；2. 信息必须被标识为推荐；3. 这里推荐的信息选完位置之后，则会消失；
     *
     * @return
     */
    public int getRecomNumber(int pageSize){
        Long countLong = Db.queryLong("SELECT COUNT(*) FROM page_edit WHERE recomPos=0 AND isReady=1");
        int count = countLong.intValue();
        return count % pageSize == 0 ? (count / pageSize) : (count / pageSize + 1);
    }

    /**
     * 获取推荐集中营中二级推荐分类信息
     * @param secondType
     * @return
     */
    public List<Record> getSecondRecom(int secondType){
        return Db.find("SELECT page_edit.id,pageDate,editorId,imageId,imageSrc,name,imageSource,firstTitle,thirdTypeName,pageFrom,sourceAddress FROM page_edit,page_titleimage,type_info,com_userinfo WHERE page_edit.titleImage=page_titleimage.imageId AND page_edit.editorId=com_userinfo.id AND page_edit.typeId=type_info.id AND pageType=0 AND recomPos=0 AND isReady=1 AND secondType=? ORDER BY pageDate DESC", secondType);
    }

    /**
     * 获取推荐集中营中三级推荐分类信息
     * @param thirdType
     * @return
     */
    public List<Record> getThirdRecom(int thirdType){
        return Db.find("SELECT page_edit.id,pageDate,editorId,imageId,imageSrc,name,imageSource,firstTitle,thirdTypeName,pageFrom,sourceAddress FROM page_edit,page_titleimage,type_info,com_userinfo WHERE page_edit.titleImage=page_titleimage.imageId AND page_edit.editorId=com_userinfo.id AND page_edit.typeId=type_info.id AND pageType=0 AND recomPos=0 AND isReady=1 AND type_info.id=? ORDER BY pageDate DESC",thirdType);
    }

    /**
     * 获取某一篇文章，通过title关键字查询获得
     */
    public List<Record> getPageByKey(String keyword){
        return Db.find("SELECT page_edit.id,pageDate,pageType,editorId,imageId,imageSrc,name,editTypeId,imageSource,firstTitle,thirdTypeName,pageFrom,recomPos,isReady,sourceAddress \n" +
                "FROM page_edit,page_titleimage,type_info,com_userinfo \n" +
                "WHERE page_edit.titleImage=page_titleimage.imageId AND page_edit.editorId=com_userinfo.id AND page_edit.typeId=type_info.id AND firstTitle like ?",keyword);
    }

    /**
     * 把一条信息设置为推荐信息，不需要审核？
     * 添加推荐标识：1. 把推荐标识（recomPos）改成0; 2. 把isReady改成1
     * @param pageId
     */
    public void addRecom(int pageId){

        pageEditDao.findById(pageId).set("pageType",0).set("recomPos",0).set("isReady",1).update();

    }

    /**
     * 给要推荐的文章设置位置
     */
    public void setRecomPos(int pageId, int recompos){
        PageEdit.pageEditDao.findById(pageId).set("recomPos",recompos).update();
    }

    /**
     * 把一条已推荐的信息放回推荐集中营
     * 去掉推荐标识：1. 把推荐标识（recomPos）改成0
     *
     * @param pageId
     * @return
     */
    public boolean removeRecom(int pageId){
        try {
            pageEditDao.findById(pageId).set("recomPos", 0).set("pageType",0).set("isTodayRecom",0).update();
        }catch (Exception exception){
            LOGGER.error("把一条已推荐的信息放回推荐集中营出错...",exception);
            return false;
        }
        return true;
    }

    /**
     * 把推荐集中营中的一条信息取消推荐资格
     * 取消推荐各自：1. 只从推荐集中营中消失，在原来三级分类中仍然有此条信息；2. 为了让推荐集中营看起来“干净”一点；
     *
     * @param pageId
     * @return
     */
    public boolean removeRecomTag(int pageId){
        try {
            pageEditDao.findById(pageId).set("recomPos", -1).update();
        }catch (Exception exception){
            return false;
        }
        return true;
    }

    /**
     * 把信息标识为审核通过
     * 审核通过：1. 把信息的isReady值改为1；
     *
     * @param pageId
     * @return
     */
    public boolean pass(int pageId){
        try {
            pageEditDao.findById(pageId).set("isReady", 1).update();
        }catch (Exception exception){
            return false;
        }
        return true;
    }

    /**
     * 审核通过的信息后悔了
     * 后悔了：将信息审核通过的标识isReady设置为0
     *
     * @param pageId
     * @return
     */
    public boolean removePass(int pageId){
        try {
            pageEditDao.findById(pageId).set("isReady", 0).update();
        }catch (Exception exception){
            return false;
        }
        return true;
    }

    /**
     * 设置主题文章的顺序
     */
    public boolean setSubOrder(int pageId,int orderIndex){
        try{
            pageEditDao.findById(pageId).set("subjectOrderIndex", orderIndex).update();
        }catch (Exception exception){
            return false;
        }
        return true;
    }

    /**
     * 设置精选文章的顺序
     */
    public boolean setJingOrder(int pageId,int orderIndex){
        try{
            pageEditDao.findById(pageId).set("recomPos",orderIndex).update();
        }catch (Exception exception){
            return false;
        }
        return  true;
    }

    /**
     * 设置整合文章的顺序,和上述一抹一样，就不调用了，直接调用上一个函数就好了，艹
     */
    public boolean setZhengOrder(int pageId,int orderIndex){
        try{
            pageEditDao.findById(pageId).set("recomPos",orderIndex).update();
        }catch (Exception exception){
            return false;
        }
        return true;
    }

    /**
     * 从page_edit表中获取当日要推送的信息
     * 当日要推送的信息：1. 标志位isReady=1；2. 推送日期要是当日；
     *
     * @return
     */
    public List<PageEdit> getTodayInfo(){
        return pageEditDao.find("SELECT id,pageDate,editorId,pageContent,titleImage,firstTitle,secondTitle,typeId,pageType,pageFrom,isTodayRecom,recomPos,sourceAddress,subjectOrderIndex FROM page_edit WHERE isReady=1 AND pageDate=CURDATE() AND isValid=1");
    }

    /**
     * 根据pageId得到文章相关信息
     *
     * @param pageId
     * @return
     */
    public List<Record> getPageInfo(int pageId){
        return Db.find("SELECT firstTitle,pageDate,pageFrom,imageSrc,pageImageSrc,sourceAddress,pageContent FROM page_edit,page_titleimage WHERE page_edit.titleImage=page_titleimage.imageid AND page_edit.id=?",pageId);
    }

    /**
     * 将page_edit中拷贝到page_info中的信息的isValid设置成0
     *
     * @return
     */
    public boolean updateEditValid(){
        try{
            Db.update("UPDATE page_edit SET isValid=0 WHERE isValid=1 AND pageDate=CURDATE() AND isReady=1");
        }catch (Exception exception){
            LOGGER.error("将page_edit中拷贝到page_info中的信息的isValid设置成0出错",exception);
            return false;
        }
        return true;
    }

    /**
     * 将page_edit中当天要显示的信息的isReady置为1
     *
     * @return
     */
    public boolean acceptAllArticle(){
        try{
            Db.update("UPDATE page_edit SET isReady = 1 WHERE pageDate = CURDATE()");
        }catch (Exception exception){
            LOGGER.error("将page_edit中所有当天要显示的信息的isReady都置为1");
            return false;
        }
        return true;
    }

    /**
     * 获取推荐界面信息，新接口
     *
     * @return
     */
    public Map<String,Object> getRecomPageInfo(){
        Map<String, Object> recomMap = new HashMap<>();

        String sqlStr = "";

        // 1. 获取精选信息列表（条件：recomPos=2、3、4）
        sqlStr = "SELECT pageId,imageSrc2 AS imageSrc,firstTitle,secondType,thirdTypeName,recomPos FROM page_edit WHERE recomPos BETWEEN 2 AND 4 ORDER BY recomPos ASC";
        List chosenList = Db.query(sqlStr);
        if (chosenList.isEmpty()) {
            LOGGER.error("获取精选信息列表,取得的chosenList为空");
        }
        return null;
    }

    /**
     * 刷新page_edit设置 isTodayRecom为1的信息isTodayRecom置0
     *
     * @return
     */
    public boolean updateEditTodayRecom(){
        int updateResult = Db.update("UPDATE page_edit SET isTodayRecom=0 WHERE isTodayRecom=1");
        if(updateResult==0){
            return false;
        }else {
            return true;
        }
    }
}
